home *** CD-ROM | disk | FTP | other *** search
/ Aminet 52 / Aminet 52 (2002)(GTI - Schatztruhe)[!][Dec 2002].iso / Aminet / game / think / AmiChess.lha / AmiChess / src / sort.c < prev    next >
C/C++ Source or Header  |  2002-10-31  |  6KB  |  248 lines
  1. #include <stdio.h>
  2.  
  3. #include "common.h"
  4.  
  5. #define WEIGHT  12
  6. #define HASHSORTSCORE   INFINITY
  7. #define KILLERSORTSCORE 1000
  8. #define CASTLINGSCORE   500
  9.  
  10. void SortCaptures (short ply)
  11. {
  12.    leaf *p;
  13.    int temp, f, t;
  14.  
  15.    for (p = TreePtr[ply]; p < TreePtr[ply+1]; p++)
  16.    {
  17.       f = Value[cboard[FROMSQ(p->move)]];
  18.       t = Value[cboard[TOSQ(p->move)]];
  19.       if (f < t)
  20.          p->score = t - f;
  21.       else
  22.       {
  23.          temp = SwapOff (p->move);
  24.      p->score = (temp < 0 ? -INFINITY : temp);
  25.       }
  26.    }
  27. }
  28.  
  29.  
  30. void SortMoves (short ply)
  31. {
  32.    leaf *p;
  33.    short f, t, m, tovalue, side, xside;
  34.    BitBoard enemyP;
  35.  
  36.    side = board.side;
  37.    xside = 1^side;
  38.    enemyP = board.b[xside][pawn];
  39.  
  40.    for (p = TreePtr[ply]; p < TreePtr[ply+1]; p++)
  41.    {
  42.       p->score = -INFINITY;
  43.       f = FROMSQ (p->move);
  44.       t = TOSQ (p->move);
  45.       m = p->move & MOVEMASK;
  46.  
  47.       /* Hash table move (highest score) */
  48.       if (m == Hashmv[ply])
  49.          p->score += HASHSORTSCORE;
  50.       else if (cboard[t] != 0 || p->move & PROMOTION)
  51.       {
  52.          tovalue = WEIGHT * (Value[cboard[t]] + Value[PROMOTEPIECE (p->move)]);
  53.          p->score += tovalue - Value[cboard[f]];
  54.       }
  55.       /* Killers */
  56.       else if (m == killer1[ply] || m == killer2[ply])
  57.          p->score += KILLERSORTSCORE; 
  58.       else if (ply > 2 && (m == killer1[ply-2] || m == killer2[ply-2]))
  59.          p->score += KILLERSORTSCORE; 
  60.  
  61.       p->score += history[side][(p->move & 0x0FFF)] + taxicab[f][D5] - taxicab[t][E4];
  62.  
  63.       if ( cboard[f] == pawn ) {
  64.         /* Look at pushing Passed pawns first */
  65.         if ( (enemyP & PassedPawnMask[side][t]) == NULLBITBOARD )
  66.            p->score +=50;
  67.       } 
  68.  
  69.    }
  70. }
  71.  
  72. void SortRoot (void)
  73. {
  74.    leaf *p;
  75.    int f, t ;
  76.    short side, xside;
  77.    BitBoard enemyP;
  78.  
  79.    side = board.side;
  80.    xside = 1^side;
  81.    enemyP = board.b[xside][pawn];
  82.  
  83.    for (p = TreePtr[1]; p < TreePtr[2]; p++)
  84.    {
  85.       f = Value[cboard[FROMSQ(p->move)]];
  86.       t = Value[cboard[TOSQ(p->move)]];
  87.       if (cboard[TOSQ(p->move)] != 0 || (p->move & PROMOTION))
  88.       {
  89.          f = Value[cboard[FROMSQ(p->move)]];
  90.          t = Value[cboard[TOSQ(p->move)]];
  91.          if (f < t)
  92.             p->score = -1000 + t - f;
  93.          else
  94.             p->score = -1000 + SwapOff (p->move);
  95.       }
  96.       else 
  97.          p->score = -3000 + SwapOff (p->move);
  98.  
  99.       p->score += taxicab[FROMSQ(p->move)][D5] - taxicab[TOSQ(p->move)][E4];
  100.  
  101.       if ( f == pawn ) {
  102.         /* Look at pushing Passed pawns first */
  103.         if ( (enemyP & PassedPawnMask[side][TOSQ(p->move)]) == NULLBITBOARD )
  104.            p->score +=50;
  105.       } 
  106.  
  107.    }
  108. }
  109.  
  110.  
  111. void pick (leaf *head, short ply)
  112. {
  113.    int best;
  114.    leaf *p, *pbest, tmp;
  115.  
  116.    best = head->score;
  117.    pbest = head;
  118.    for (p = head+1; p < TreePtr[ply+1]; p++) 
  119.    {
  120.       if (p->score > best)
  121.       {
  122.          pbest = p;
  123.      best = p->score;
  124.       }
  125.    }
  126.  
  127.    /*  Swap pbest with the head  */
  128.    tmp = *head;
  129.    *head = *pbest;
  130.    *pbest = tmp; 
  131. }
  132.  
  133.  
  134. short PhasePick (leaf **p1, short ply)
  135. {
  136.    static leaf* p[MAXPLYDEPTH];
  137.    leaf *p2;
  138.    int mv;
  139.    short side;
  140.  
  141.    side = board.side;
  142.    switch (pickphase[ply])
  143.    {
  144.       case PICKHASH:
  145.          TreePtr[ply+1] = TreePtr[ply];
  146.          pickphase[ply] = PICKGEN1;
  147.          if (Hashmv[ply] && IsLegalMove (Hashmv[ply]))
  148.          {
  149.             TreePtr[ply+1]->move = Hashmv[ply];
  150.             *p1 = TreePtr[ply+1]++;
  151.             return (true);
  152.          }
  153.  
  154.       case PICKGEN1:
  155.          pickphase[ply] = PICKCAPT;
  156.          p[ply] = TreePtr[ply+1];
  157.          GenCaptures (ply);
  158.          for (p2 = p[ply]; p2 < TreePtr[ply+1]; p2++)
  159.             p2->score = SwapOff(p2->move) * WEIGHT + 
  160.                 Value[cboard[TOSQ(p2->move)]];
  161.  
  162.       case PICKCAPT:
  163.          while (p[ply] < TreePtr[ply+1])
  164.          {
  165.             pick (p[ply], ply);
  166.             if ((p[ply]->move & MOVEMASK) == Hashmv[ply])
  167.             {
  168.            p[ply]++;
  169.            continue;
  170.             } 
  171.             *p1 = p[ply]++;
  172.             return (true);
  173.          }
  174.  
  175.       case PICKKILL1:
  176.          pickphase[ply] = PICKKILL2;
  177.          if (killer1[ply] && killer1[ply] != Hashmv[ply] && 
  178.                 IsLegalMove (killer1[ply]))
  179.          {
  180.             TreePtr[ply+1]->move = killer1[ply];
  181.             *p1 = TreePtr[ply+1];
  182.             TreePtr[ply+1]++;
  183.             return (true);
  184.          }
  185.          
  186.       case PICKKILL2:
  187.          pickphase[ply] = PICKGEN2;
  188.          if (killer2[ply] && killer2[ply] != Hashmv[ply] && 
  189.                 IsLegalMove (killer2[ply]))
  190.          {
  191.             TreePtr[ply+1]->move = killer2[ply];
  192.             *p1 = TreePtr[ply+1];
  193.             TreePtr[ply+1]++;
  194.             return (true);
  195.          }
  196.  
  197.       case PICKGEN2:
  198.          pickphase[ply] = PICKREST;
  199.          p[ply] = TreePtr[ply+1];
  200.          GenNonCaptures (ply);
  201.          for (p2 = p[ply]; p2 < TreePtr[ply+1]; p2++)
  202.      {
  203.             p2->score = history[side][(p2->move & 0x0FFF)] + 
  204.         taxicab[FROMSQ(p2->move)][D5]  - taxicab[TOSQ(p2->move)][E4];
  205.         if (p2->move & CASTLING)
  206.            p2->score += CASTLINGSCORE;
  207.          }
  208.      
  209.       case PICKREST:
  210.          while (p[ply] < TreePtr[ply+1])
  211.          {
  212.             pick (p[ply], ply);
  213.             mv = p[ply]->move & MOVEMASK;
  214.             if (mv == Hashmv[ply] || mv == killer1[ply] || 
  215.         mv == killer2[ply])
  216.         {
  217.            p[ply]++;
  218.                continue;
  219.         }
  220.             *p1 = p[ply]++;
  221.             return (true);
  222.          }
  223.    }
  224.    return (false);
  225. } 
  226.  
  227.  
  228. short PhasePick1 (leaf **p1, short ply)
  229. {
  230.    static leaf* p[MAXPLYDEPTH];
  231.  
  232.    switch (pickphase[ply])
  233.    {
  234.       case PICKHASH:
  235.          pickphase[ply] = PICKREST;
  236.          p[ply] = TreePtr[ply];
  237.  
  238.       case PICKREST:
  239.      while (p[ply] < TreePtr[ply+1])
  240.          {
  241.             pick (p[ply], ply);
  242.             *p1 = p[ply]++;
  243.             return (true);
  244.          }
  245.    }
  246.    return (false);
  247. }
  248.